// clang++ -march=x64-64-v4 -I/home/marco/repos/xsimd/include -DXSIMD_DEFAULT_ARCH=xsimd::avx512vl_256 /tmp/xsimd_stray_bits.cpp -o /tmp/xsimd_stray_bits
#include <cstdio>
#include <cstdint>
#include "xsimd/xsimd.hpp"


#include <iostream>
#include <typeinfo>
#include <cxxabi.h>
#include <memory>

// Helper function to demangle typeid names
std::string demangle(const char* mangled) {
    int status = 0;
    std::unique_ptr<char, decltype(&free)> result(
        abi::__cxa_demangle(mangled, nullptr, nullptr, &status),
        &free
    );
    return (status == 0) ? result.get() : mangled;
}


static int fail_count = 0;

#define EXPECT(label, expr, expected)                                          \
    do {                                                                       \
        const bool got = (expr);                                               \
        const bool ok  = (got == (expected));                                  \
        std::printf("    %-58s expected %-5s got %-5s  %s\n",                  \
                    (label),                                                   \
                    (expected) ? "true" : "false",                             \
                    got ? "true" : "false",                                    \
                    ok ? "PASS" : "FAIL");                                     \
        if (!ok) ++fail_count;                                                 \
    } while (0)

template <class T>
int check() {
    using A = xsimd::avx512vl_256;
    using B = xsimd::batch<T, A>;
    std::cout << "\n=== " << demangle(typeid(B).name())
              << "  (arch=" << demangle(typeid(A).name())
              << ", lanes=" << B::size << ") ===\n";

    B a(T(1));
    std::cout << "  a = " << a << "\n";

    // a equals itself
    EXPECT("a should equal itself                                 [all(a == a)]",
           xsimd::all(a == a), true);
    EXPECT("a should not differ from itself                       [any(a != a)]",
           xsimd::any(a != a), false);

    // combine two logically empty masks
    auto m1 = (a != a);
    auto m2 = (a != a);
    EXPECT("AND of two empty masks should be empty                [any(m1 & m2)]",
           xsimd::any(m1 & m2), false);
    EXPECT("OR  of two empty masks should be empty                [any(m1 | m2)]",
           xsimd::any(m1 | m2), false);
    EXPECT("XOR of identical empty masks should be empty          [any(m1 ^ m2)]",
           xsimd::any(m1 ^ m2), false);

    // complement of an empty mask is a full mask
    auto m_not = ~m1;
    EXPECT("complement of an empty mask should be full            [all(~m1)]",
           xsimd::all(m_not), true);
    EXPECT("complement of an empty mask should be nonempty        [any(~m1)]",
           xsimd::any(m_not), true);

    // a bool batch equals itself
    EXPECT("a bool mask should equal itself                       [all(m_not == m_not)]",
           xsimd::all(m_not == m_not), true);

    return 0;
}

int main() {
    int fails = 0;
    fails += check<int8_t>();
    fails += check<int16_t>();
    fails += check<int32_t>();
    fails += check<int64_t>();
    fails += check<float>();
    fails += check<double>();
    std::printf("%d failures\n", fails);
    return fails != 0 ? 1 : 0;
}